home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2004 #11 / Amiga Plus CD - 2004 - No. 11.iso / AmiSoft / Util / conv / Acvt.lha / Acvt 1.07 / sources / cdisk.cpp < prev    next >
C/C++ Source or Header  |  1999-06-10  |  6KB  |  277 lines
  1. //    This program is free software; you can redistribute it and/or modify
  2. //    it under the terms of the GNU General Public License as published by
  3. //    the Free Software Foundation; either version 2 of the License, or
  4. //    any later version.
  5. //
  6. //    This program is distributed in the hope that it will be useful,
  7. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9. //    GNU General Public License for more details.
  10. //
  11. //    You should have received a copy of the GNU General Public License
  12. //    along with this program; if not, write to the Free Software
  13. //    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  14. //
  15.  
  16. #include "cdisk.h"
  17. #include "cdsk_atr.h"
  18. #include "cdsk_xfd.h"
  19. #include "cdsk_dcm.h"
  20. #include "cdsk_scp.h"
  21.  
  22.  
  23. CDisk::CDisk()
  24. { 
  25.     m_bOpened = FALSE; 
  26.     m_pbtMemory = NULL;
  27.  
  28.     #ifdef _MEMORY_DUMP_
  29.         printf( "CDisk constructed: %08X\n", this );
  30.     #endif
  31. }
  32.  
  33. CDisk::~CDisk()
  34. {
  35.     if ( m_pbtMemory )
  36.     {
  37.         delete [] m_pbtMemory;
  38.         m_pbtMemory = NULL;
  39.     }
  40.  
  41.     #ifdef _MEMORY_DUMP_
  42.         printf( "CDisk destructed: %08X\n", this );
  43.     #endif
  44. }
  45.  
  46. BOOL CDisk::Duplicate( CDisk* pDisk )
  47. {
  48.     if ( !Format( & ( pDisk->m_geometry ) ) )
  49.         return FALSE;
  50.  
  51.     memcpy( m_pbtMemory, pDisk->m_pbtMemory, pDisk->m_iAllocated );
  52.     return TRUE;
  53. }
  54.  
  55. BOOL CDisk::Format( DISK_GEOMETRY* pgeo )
  56. {
  57.     int iSectors = pgeo->iSides * pgeo->iTracks * pgeo->iSectorsPerTrack;
  58.  
  59.     if ( m_pbtMemory )
  60.         delete [] m_pbtMemory;
  61.  
  62.     m_iAllocated = iSectors * pgeo->iBytesPerSector;
  63.     m_pbtMemory = new BYTE [ m_iAllocated ];
  64.  
  65.     if ( !m_pbtMemory )
  66.     {
  67.         sprintf( m_szLastError, "DISK: Can't format - Not enough memory!" );
  68.         return FALSE;
  69.     }
  70.  
  71.     memset( m_pbtMemory, 0, m_iAllocated );
  72.  
  73.     m_geometry.iSides = pgeo->iSides;
  74.     m_geometry.iTracks = pgeo->iTracks;
  75.     m_geometry.iSectorsPerTrack = pgeo->iSectorsPerTrack;
  76.     m_geometry.iBytesPerSector = pgeo->iBytesPerSector;
  77.     m_geometry.iSectors = iSectors;
  78.  
  79.     return TRUE;
  80. }
  81.  
  82. BOOL CDisk::ReadSector( void* pBuf, int iStartSec )
  83. {
  84.     if ( iStartSec && ( iStartSec <= m_geometry.iSectors ) )
  85.         memcpy( pBuf, m_pbtMemory + ( iStartSec - 1 ) * m_geometry.iBytesPerSector, m_geometry.iBytesPerSector );
  86.     else
  87.     {
  88.         sprintf( m_szLastError, "DISK: Reading non-existent sector: %04X", iStartSec );
  89.         return FALSE;
  90.     }
  91.  
  92.     return TRUE;
  93. }
  94.  
  95. BOOL CDisk::ReadSectors( void* pBuf, int iStartSec, int iSecs )
  96. {
  97.     while( iSecs )
  98.     {
  99.         if ( !ReadSector( pBuf, iStartSec ) )
  100.             return FALSE;
  101.  
  102.         iStartSec++;
  103.         iSecs--;
  104.         pBuf = (BYTE*)pBuf + m_geometry.iBytesPerSector;
  105.     }
  106.  
  107.     return TRUE;
  108. }
  109.  
  110. BOOL CDisk::WriteSector( int iStartSec, void* pBuf )
  111. {
  112.     //printf( " ws: %d ", iStartSec );
  113.     if ( iStartSec && ( iStartSec <= m_geometry.iSectors ) )
  114.         memcpy( m_pbtMemory + ( iStartSec - 1 ) * m_geometry.iBytesPerSector, pBuf, m_geometry.iBytesPerSector );
  115.     else
  116.     {
  117.         sprintf( m_szLastError, "DISK: Writing non-existent sector: %04X", iStartSec );
  118.         return FALSE;
  119.     }
  120.  
  121.     return TRUE;
  122. }
  123.  
  124. void GuessClassicSizes( int iSectors, int iSectorSize, DISK_GEOMETRY* pGeometry )
  125. {
  126.     pGeometry->iSides = 1;
  127.     pGeometry->iBytesPerSector = iSectorSize;
  128.  
  129.     pGeometry->iTracks = 1;
  130.     pGeometry->iSectorsPerTrack = iSectors;
  131.  
  132.     switch( iSectors )
  133.     {
  134.         case 720:
  135.             switch( iSectorSize )
  136.             {
  137.                 case 0x80:
  138.                     pGeometry->iTracks = 40;
  139.                     pGeometry->iSectorsPerTrack = 18;
  140.                     break;
  141.  
  142.                 case 0x100:
  143.                     pGeometry->iTracks = 40;
  144.                     pGeometry->iSectorsPerTrack = 18;
  145.                     break;
  146.             }
  147.             break;
  148.  
  149.         case 1040:
  150.             pGeometry->iTracks = 40;
  151.             pGeometry->iSectorsPerTrack = 26;
  152.             break;
  153.  
  154.     }
  155.  
  156. }
  157.  
  158. //returns ptr to disk type name
  159. char* GetDiskTypeName( DISK_TYPE disktype )
  160. {
  161.     switch( disktype )
  162.     {
  163.         case DISK_XFD:
  164.             return "XFD";
  165.  
  166.         case DISK_ATR:
  167.             return "ATR";
  168.  
  169.         case DISK_XFDb:
  170.             return "XFDb";
  171.  
  172.         case DISK_ATRb:
  173.             return "ATRb";
  174.  
  175.         case DISK_DCM:
  176.             return "DCM";
  177.  
  178.         case DISK_SCP:
  179.             return "SCP";
  180.  
  181.         default:
  182.             return "None";
  183.     }
  184. }
  185.  
  186. //returns ptr to disk type extension
  187. char* GetDiskTypeExt( DISK_TYPE disktype )
  188. {
  189.     switch( disktype )
  190.     {
  191.         case DISK_XFD:
  192.         case DISK_XFDb:
  193.             return "xfd";
  194.  
  195.         case DISK_ATR:
  196.         case DISK_ATRb:
  197.             return "atr";
  198.  
  199.         case DISK_DCM:
  200.             return "dcm";
  201.  
  202.         case DISK_SCP:
  203.             return "scp";
  204.  
  205.         default:
  206.             return "xxx";
  207.     }
  208. }
  209.  
  210. DISKINIT_RETCODE InitializeDisk( CDisk** ppDisk, DISK_TYPE disktype, char* szFname, BOOL bVerbose, BOOL bRepair, BOOL bRepairAuto )
  211. {
  212.     switch( disktype )
  213.     {
  214.         case DISK_ATR:
  215.             *ppDisk = new CAtr();
  216.             break;
  217.  
  218.         case DISK_SCP:
  219.             *ppDisk = new CScp();
  220.             break;
  221.  
  222.         case DISK_DCM:
  223.             *ppDisk = new CDcm();
  224.             break;
  225.  
  226.         case DISK_XFD:
  227.             *ppDisk = new CXfd();
  228.             break;
  229.  
  230.         default:
  231.             if ( bVerbose )
  232.                 fprintf( stderr, "Invalid disk type specified!\n" );
  233.             return DI_RET_CANT_CONTINUE;
  234.     }
  235.  
  236.     if ( !*ppDisk )
  237.     {
  238.         if ( bVerbose )
  239.              fprintf( stderr, "Can't initialize disk driver!\n" );
  240.          return DI_RET_CONTINUE;
  241.     }
  242.  
  243.     if ( !(*ppDisk)->Load( szFname, bRepair, bRepairAuto ) )
  244.     {
  245.         int iError = (*ppDisk)->GetErrorCode();
  246.  
  247.         DISKINIT_RETCODE ret = DI_RET_CONTINUE;
  248.  
  249.         switch( iError )
  250.         {
  251.             case CATR_FORMAT_VIOLATED:
  252.             case CXFD_FORMAT_VIOLATED:
  253.             case CDISK_ERROR_CANT_OPEN:
  254.             case CDCM_FORMAT_VIOLATED:
  255.             case CSCP_FORMAT_VIOLATED:
  256.                 ret = DI_RET_CANT_CONTINUE;
  257.                 break;
  258.         }
  259.  
  260.         if ( bVerbose || ( ret == DI_RET_CANT_CONTINUE ) )
  261.         {
  262.             printf( "Input file '%s' ", szFname );
  263.             printf( "(%s)\n", GetDiskTypeName( disktype ) );
  264.             printf( "Load failed because:\n%s\n", (*ppDisk)->GetLastError() );
  265.         }
  266.         if ( ret != DI_RET_OK )
  267.         {
  268.             delete *ppDisk;
  269.             return ret;
  270.         }
  271.     }
  272.  
  273.     return DI_RET_OK;
  274. }
  275.  
  276.  
  277.